const fs = require('fs');
const path = require('path');

// 处理命令行参数
const args = process.argv.slice(2);
let dictionaryPath = './locale/ru.json';
let sourceDir = './pages';
let debugEnabled = true;
let outputStats = true;
let exportUntranslated = true;

// 解析命令行参数
for (let i = 0; i < args.length; i++) {
  const arg = args[i];
  
  if (arg === '--dict' && i + 1 < args.length) {
    dictionaryPath = args[++i];
  } else if (arg === '--source' && i + 1 < args.length) {
    sourceDir = args[++i];
  } else if (arg === '--no-debug') {
    debugEnabled = false;
  } else if (arg === '--no-stats') {
    outputStats = false;
  } else if (arg === '--no-export') {
    exportUntranslated = false;
  } else if (arg === '--help') {
    console.log(`用法: node deepseek.js [选项]
选项:
  --dict <路径>      指定翻译字典文件路径 (默认: ./translation-dictionary.json)
  --source <目录>    指定源代码目录 (默认: ./pages)
  --no-debug         禁用调试日志输出
  --no-stats         禁用详细统计输出
  --no-export        禁用导出未翻译的文本
  --help             显示此帮助信息
`);
    process.exit(0);
  }
}

console.log(`使用翻译字典: ${dictionaryPath}`);
console.log(`处理源目录: ${sourceDir}`);

// 加载翻译字典
let translations;
try {
  translations = require(dictionaryPath);
  console.log('载入翻译字典...');
  console.log(`翻译字典包含 ${Object.keys(translations).length} 个条目`);
} catch (error) {
  console.error(`错误: 无法加载翻译字典 ${dictionaryPath}`);
  console.error(error.message);
  process.exit(1);
}

// 检查翻译字典的结构并创建逆向映射
const translationsMap = {};

// 打印几个示例条目用于调试
const sampleKeys = Object.keys(translations).slice(0, 3);
sampleKeys.forEach(key => {
  console.log(`示例: 键="${key}", 值="${translations[key]}"`);
});

// 检查翻译字典的格式，构建正确的映射
// 字典可能是 {key: 中文} 或 {中文: key} 格式
let dictFormat = 'keyToText'; // 默认假设是 {key: 中文} 格式
let hasChineseKeys = false;
let hasChineseValues = false;

for (const key in translations) {
  const value = translations[key];
  if (/[\u4e00-\u9fa5]/.test(key)) {
    hasChineseKeys = true;
  }
  if (typeof value === 'string' && /[\u4e00-\u9fa5]/.test(value)) {
    hasChineseValues = true;
  }
}

// 根据中文出现的位置确定字典格式
if (hasChineseKeys && !hasChineseValues) {
  dictFormat = 'textToKey'; // 字典是 {中文: key} 格式
  console.log('字典格式: 中文作为键，翻译键作为值');
  // 反转字典，便于查找
  for (const chineseText in translations) {
    translationsMap[chineseText] = translations[chineseText];
  }
} else if (!hasChineseKeys && hasChineseValues) {
  dictFormat = 'keyToText'; // 字典是 {key: 中文} 格式
  console.log('字典格式: 翻译键作为键，中文作为值');
  // 反转字典，便于查找
  for (const key in translations) {
    translationsMap[translations[key]] = key;
  }
} else if (hasChineseKeys && hasChineseValues) {
  dictFormat = 'mixed'; // 混合格式
  console.log('字典格式: 混合格式，同时包含中文键和中文值');
  // 构建双向映射
  for (const key in translations) {
    const value = translations[key];
    // 假设中文文本可以是键也可以是值
    if (/[\u4e00-\u9fa5]/.test(key)) {
      translationsMap[key] = value;
    }
    if (typeof value === 'string' && /[\u4e00-\u9fa5]/.test(value)) {
      translationsMap[value] = key;
    }
  }
}

// 正则表达式配置
// 注释的正则表达式
const SINGLE_LINE_COMMENT = /\/\/.*/g;
const MULTI_LINE_COMMENT = /\/\*[\s\S]*?\*\//g;

// 添加配置选项，让用户可以控制替换行为
const CONFIG = {
  replaceTagContent: true,     // 是否替换标签内纯文本
  fixNestedCalls: true,        // 是否修复嵌套$t调用
  preserveSpaces: true,        // 是否保留文本前后的空格
  autoDetectDict: true,        // 是否自动检测字典格式
  debug: debugEnabled          // 是否启用调试模式
};

// 启用详细日志输出进行调试
let debugMode = CONFIG.debug;
let globalReplacementCount = 0;

// 统计不同类型的替换
const replacementStats = {
  tagContent: 0,
  attributes: 0,
  interpolation: 0,
  scriptContent: 0,
  mixedContent: 0
};

// 转义正则表达式特殊字符
function escapeRegExp(string) {
  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

// 记录替换次数的函数
function countReplacement(type) {
  globalReplacementCount++;
  if (type && replacementStats[type] !== undefined) {
    replacementStats[type]++;
  }
}

// 替换标签内的中文文本
function replaceTagContent(content, text, key) {
  // 精确匹配标签内的纯文本
  const tagContentRegex = new RegExp(`(<([\\w-]+)([^>]*)>)([\\s\\n]*)(${escapeRegExp(text)})([\\s\\n]*)(</\\2>)`, 'g');
  
  return content.replace(tagContentRegex, (match, openTag, tagName, attrs, spaceBefore, chineseText, spaceAfter, closeTag) => {
    if (match.includes('{{') || match.includes('}}')) {
      return match; // 避免替换含有插值表达式的内容
    }
    
    if (debugMode) console.log(`替换标签内文本: ${match} => ${openTag}${spaceBefore}{{$t('${key}')}}${spaceAfter}${closeTag}`);
    countReplacement('tagContent');
    
    if (CONFIG.preserveSpaces) {
      return `${openTag}${spaceBefore}{{$t('${key}')}}${spaceAfter}${closeTag}`;
    } else {
      return `${openTag}{{$t('${key}')}}${closeTag}`;
    }
  });
}

// 替换混合内容（例如：<view>采购范围：{{ userInfo.category_name }}</view>）
function replaceMixedContent(content, text, key) {
  // 处理标签内的混合内容
  if (!text.includes('{{') && !text.includes('}}')) {
    const mixedContentRegex = new RegExp(`(<([\\w-]+)([^>]*)>)([\\s\\n]*)([^<>{}]*${escapeRegExp(text)}[^<>{}]*)(\\{\\{[^{}]+\\}\\}[^<>{}]*)?([\\s\\n]*)(</\\2>)`, 'g');
    
    return content.replace(mixedContentRegex, (match, openTag, tagName, attrs, spaceBefore, textWithChinese, interpolation = '', spaceAfter, closeTag) => {
      // 确保我们找到的是真正的混合内容
      if (!textWithChinese.includes(text)) {
        return match;
      }
      
      // 替换中文部分为$t调用
      const newText = textWithChinese.replace(new RegExp(escapeRegExp(text), 'g'), `{{$t('${key}')}}`);
      
      if (debugMode) console.log(`替换混合内容: ${match} => ${openTag}${spaceBefore}${newText}${interpolation}${spaceAfter}${closeTag}`);
      countReplacement('mixedContent');
      
      return `${openTag}${spaceBefore}${newText}${interpolation}${spaceAfter}${closeTag}`;
    });
  }
  
  return content;
}

// 替换属性中的中文
function replaceAttributes(content, text, key) {
  let result = content;
  
  // 替换静态属性
  const staticAttrRegex = new RegExp(`(\\s)(\\w+)=(['"]) *(${escapeRegExp(text)}) *(\\3)(?!\\s*v-i18n|\\s*:)`, 'g');
  result = result.replace(staticAttrRegex, (match, space, attr, quote, chineseText) => {
    if (debugMode) console.log(`替换静态属性: ${match} => ${space}:${attr}="$t('${key}')"`);
    countReplacement('attributes');
    return `${space}:${attr}="$t('${key}')"`;
  });
  
  // 替换动态属性
  const dynamicAttrRegex = new RegExp(`(:|v-bind:)(\\w+)=(['"]) *(${escapeRegExp(text)}) *(\\3)`, 'g');
  result = result.replace(dynamicAttrRegex, (match, bind, attr, quote, chineseText) => {
    if (debugMode) console.log(`替换动态属性: ${match} => ${bind}${attr}="$t('${key}')"`);
    countReplacement('attributes');
    return `${bind}${attr}="$t('${key}')"`;
  });
  
  return result;
}

// 替换插值表达式中的中文
function replaceInterpolation(content, text, key) {
  const interpolationRegex = new RegExp(`\\{\\{\\s*(['"])(${escapeRegExp(text)})(\\1)\\s*\\}\\}`, 'g');
  
  return content.replace(interpolationRegex, (match, quote, chineseText) => {
    if (debugMode) console.log(`替换文本插值: ${match} => {{ $t('${key}') }}`);
    countReplacement('interpolation');
    return `{{ $t('${key}') }}`;
  });
}

// 替换条件表达式中的中文文本，例如 {{ variable || '中文' }}
function replaceConditionalExpressions(content, text, key) {
  // 匹配模板中的条件表达式，如 {{ emplType || '这可以是任意中文' }}
  const conditionalRegex = new RegExp(`(\\{\\{\\s*\\w+\\s*\\|\\|\\s*)(['"])(${escapeRegExp(text)})(\\2)(\\s*\\}\\})`, 'g');
  
  // 处理正常条件表达式
  let processedContent = content.replace(conditionalRegex, (match, prefix, quote, chineseText, quoteEnd, suffix) => {
    if (debugMode) console.log(`替换条件表达式: ${match} => ${prefix}$t('${key}')${suffix}`);
    countReplacement('interpolation');
    return `${prefix}$t('${key}')${suffix}`;
  });
  
  // 处理错误的嵌套花括号情况，如 {{ variable || '{{$t('文本')}}' }}
  const nestedBracketsRegex = new RegExp(`(\\{\\{\\s*\\w+\\s*\\|\\|\\s*)(['"])(\\{\\{\\$t\\(['"])[^'"]*(['"]}\\)\\}\\})(\\2)(\\s*\\}\\})`, 'g');
  processedContent = processedContent.replace(nestedBracketsRegex, (match, prefix, quote, nestedStart, nestedEnd, quoteEnd, suffix) => {
    if (debugMode) console.log(`修复嵌套花括号: ${match} => ${prefix}$t('${key}')${suffix}`);
    countReplacement('interpolation');
    return `${prefix}$t('${key}')${suffix}`;
  });
  
  // 处理带有嵌套花括号的中文文本，如 {{ variable || '{{$t('中文')}}' }}
  const nestedBracketsWithTextRegex = new RegExp(`(\\{\\{\\s*\\w+\\s*\\|\\|\\s*)(['"])(\\{\\{\\$t\\(['"])(${escapeRegExp(text)})(['"]}\\)\\}\\})(\\2)(\\s*\\}\\})`, 'g');
  processedContent = processedContent.replace(nestedBracketsWithTextRegex, (match, prefix, quote, nestedStart, chineseText, nestedEnd, quoteEnd, suffix) => {
    if (debugMode) console.log(`修复带中文的嵌套花括号: ${match} => ${prefix}$t('${key}')${suffix}`);
    countReplacement('interpolation');
    return `${prefix}$t('${key}')${suffix}`;
  });
  
  return processedContent;
}

// 替换三元表达式中的嵌套花括号问题，例如 {{ item.status == 3 ? "{{$t('当前')}}" : "期望" }}
function replaceTernaryExpressions(content) {
  // 匹配三元表达式中嵌套花括号的模式，如 {{ item.status == 3 ? "{{$t('当前')}}" : "期望" }}
  const ternaryRegex = /(\{\{\s*(?:[\w\.]+\s*(?:==|!=|<=|>=|<|>)\s*[\w\.]+)\s*\?\s*)(['"])(\{\{\$t\(['"])([^'"]+)([']\)\}\})(\2)(\s*:)/g;
  
  // 处理三元表达式中的嵌套花括号
  let processedContent = content.replace(ternaryRegex, (match, prefix, quote, nestedStart, translationKey, nestedEnd, quoteEnd, suffix) => {
    if (debugMode) console.log(`修复三元表达式中的嵌套花括号: ${match} => ${prefix}$t('${translationKey}')${suffix}`);
    countReplacement('interpolation');
    return `${prefix}$t('${translationKey}')${suffix}`;
  });
  
  // 匹配更一般的三元表达式中嵌套花括号的模式
  const generalTernaryRegex = /(\{\{\s*[^?:{}]+\?\s*)(['"])(\{\{\$t\(['"])([^'"]+)([']\)\}\})(\2)(\s*:)/g;
  processedContent = processedContent.replace(generalTernaryRegex, (match, prefix, quote, nestedStart, translationKey, nestedEnd, quoteEnd, suffix) => {
    if (debugMode) console.log(`修复一般三元表达式中的嵌套花括号: ${match} => ${prefix}$t('${translationKey}')${suffix}`);
    countReplacement('interpolation');
    return `${prefix}$t('${translationKey}')${suffix}`;
  });
  
  // 匹配另一种形式的三元表达式，如 {{ item.status == 3 ? "{{$t('当前')}}" : $t('期望') }}
  const complexTernaryRegex = /(\{\{\s*(?:[\w\.]+\s*(?:==|!=|<=|>=|<|>)\s*[\w\d\.]+)\s*\?\s*)(['"])(\{\{[\s\S]*?\}\})(\2)(\s*:)/g;
  processedContent = processedContent.replace(complexTernaryRegex, (match, prefix, quote, nestedExpression, quoteEnd, suffix) => {
    // 提取嵌套的$t调用
    const $tMatch = nestedExpression.match(/\{\{\s*\$t\(['"]([^'"]+)['"]\)\s*\}\}/);
    if ($tMatch) {
      const translationKey = $tMatch[1];
      if (debugMode) console.log(`修复复杂三元表达式中的嵌套花括号: ${match} => ${prefix}$t('${translationKey}')${suffix}`);
      countReplacement('interpolation');
      return `${prefix}$t('${translationKey}')${suffix}`;
    }
    return match; // 如果不是$t调用，保持不变
  });
  
  // 匹配三元表达式的第二部分（冒号后面）的嵌套花括号，如 {{ item.status == 3 ? "当前" : "{{$t('期望')}}" }}
  const ternarySecondPartRegex = /(\{\{\s*(?:[\w\.]+\s*(?:==|!=|<=|>=|<|>)\s*[\w\.]+)\s*\?\s*(?:[^:]+)\s*:\s*)(['"])(\{\{\$t\(['"])([^'"]+)([']\)\}\})(\2)(\s*\}\})/g;
  
  processedContent = processedContent.replace(ternarySecondPartRegex, (match, prefix, quote, nestedStart, translationKey, nestedEnd, quoteEnd, suffix) => {
    if (debugMode) console.log(`修复三元表达式第二部分的嵌套花括号: ${match} => ${prefix}$t('${translationKey}')${suffix}`);
    countReplacement('interpolation');
    return `${prefix}$t('${translationKey}')${suffix}`;
  });
  
  // 匹配更一般的三元表达式第二部分的嵌套花括号
  const generalTernarySecondPartRegex = /(\{\{\s*[^?:{}]+\?\s*[^:]+\s*:\s*)(['"])(\{\{\$t\(['"])([^'"]+)([']\)\}\})(\2)(\s*\}\})/g;
  processedContent = processedContent.replace(generalTernarySecondPartRegex, (match, prefix, quote, nestedStart, translationKey, nestedEnd, quoteEnd, suffix) => {
    if (debugMode) console.log(`修复一般三元表达式第二部分的嵌套花括号: ${match} => ${prefix}$t('${translationKey}')${suffix}`);
    countReplacement('interpolation');
    return `${prefix}$t('${translationKey}')${suffix}`;
  });
  
  // 处理更复杂的嵌套三元表达式的第二部分
  const complexTernarySecondPartRegex = /(\{\{\s*(?:[\w\.]+\s*(?:==|!=|<=|>=|<|>)\s*[\w\d\.]+)\s*\?\s*(?:[^:]+)\s*:\s*)(['"])(\{\{[\s\S]*?\}\})(\2)(\s*\}\})/g;
  
  processedContent = processedContent.replace(complexTernarySecondPartRegex, (match, prefix, quote, nestedExpression, quoteEnd, suffix) => {
    // 提取嵌套的$t调用
    const $tMatch = nestedExpression.match(/\{\{\s*\$t\(['"]([^'"]+)['"]\)\s*\}\}/);
    if ($tMatch) {
      const translationKey = $tMatch[1];
      if (debugMode) console.log(`修复复杂三元表达式第二部分的嵌套花括号: ${match} => ${prefix}$t('${translationKey}')${suffix}`);
      countReplacement('interpolation');
      return `${prefix}$t('${translationKey}')${suffix}`;
    }
    return match; // 如果不是$t调用，保持不变
  });
  
  // 处理不带引号的三元表达式第一部分
  const unquotedTernaryRegex = /(\{\{\s*(?:[\w\.]+\s*(?:==|!=|<=|>=|<|>)\s*[\w\.]+)\s*\?\s*)(\{\{\$t\(['"])([^'"]+)([']\)\}\})(\s*:)/g;
  processedContent = processedContent.replace(unquotedTernaryRegex, (match, prefix, nestedStart, translationKey, nestedEnd, suffix) => {
    if (debugMode) console.log(`修复不带引号的三元表达式中的嵌套花括号: ${match} => ${prefix}$t('${translationKey}')${suffix}`);
    countReplacement('interpolation');
    return `${prefix}$t('${translationKey}')${suffix}`;
  });
  
  // 处理不带引号的三元表达式第二部分
  const unquotedTernarySecondPartRegex = /(\{\{\s*(?:[\w\.]+\s*(?:==|!=|<=|>=|<|>)\s*[\w\.]+)\s*\?\s*(?:[^:]+)\s*:\s*)(\{\{\$t\(['"])([^'"]+)([']\)\}\})(\s*\}\})/g;
  processedContent = processedContent.replace(unquotedTernarySecondPartRegex, (match, prefix, nestedStart, translationKey, nestedEnd, suffix) => {
    if (debugMode) console.log(`修复不带引号的三元表达式第二部分的嵌套花括号: ${match} => ${prefix}$t('${translationKey}')${suffix}`);
    countReplacement('interpolation');
    return `${prefix}$t('${translationKey}')${suffix}`;
  });
  
  return processedContent;
}

// 替换所有三元表达式中的中文文本为$t调用
function replaceChineseInTernary(content) {
  // 1. 处理三元表达式第一部分（问号前）的中文文本 - 带引号版本
  // 匹配如 {{ item.status == 3 ? "当前" : ... }}
  const ternaryFirstPartRegex = /(\{\{\s*(?:[\w\.]+\s*(?:==|!=|<=|>=|<|>)\s*[\w\.]+)\s*\?\s*)(['"])([^'"]*[\u4e00-\u9fa5][^'"]*)(\2)(\s*:)/g;
  
  let processedContent = content.replace(ternaryFirstPartRegex, (match, prefix, quote, chineseText, quoteEnd, suffix) => {
    if (debugMode) console.log(`替换三元表达式第一部分的中文: ${match} => ${prefix}$t('${chineseText}')${suffix}`);
    countReplacement('interpolation');
    return `${prefix}$t('${chineseText}')${suffix}`;
  });
  
  // 2. 处理三元表达式第二部分（冒号后）的中文文本 - 带引号版本
  // 匹配如 {{ item.status == 3 ? ... : "期望" }}
  const ternarySecondPartRegex = /(\{\{\s*(?:[\w\.]+\s*(?:==|!=|<=|>=|<|>)\s*[\w\.]+)\s*\?\s*(?:[^:]+)\s*:\s*)(['"])([^'"]*[\u4e00-\u9fa5][^'"]*)(\2)(\s*\}\})/g;
  
  processedContent = processedContent.replace(ternarySecondPartRegex, (match, prefix, quote, chineseText, quoteEnd, suffix) => {
    if (debugMode) console.log(`替换三元表达式第二部分的中文: ${match} => ${prefix}$t('${chineseText}')${suffix}`);
    countReplacement('interpolation');
    return `${prefix}$t('${chineseText}')${suffix}`;
  });
  
  // 3. 处理更一般的条件表达式
  // 匹配如 {{ item.status == 3 || "期望" }}
  const conditionalOrRegex = /(\{\{\s*[\w\.]+\s*(?:==|!=|<=|>=|<|>|&&|\|\|)\s*[\w\.]+\s*\|\|\s*)(['"])([^'"]*[\u4e00-\u9fa5][^'"]*)(\2)(\s*\}\})/g;
  
  processedContent = processedContent.replace(conditionalOrRegex, (match, prefix, quote, chineseText, quoteEnd, suffix) => {
    if (debugMode) console.log(`替换条件表达式中的中文: ${match} => ${prefix}$t('${chineseText}')${suffix}`);
    countReplacement('interpolation');
    return `${prefix}$t('${chineseText}')${suffix}`;
  });
  
  // 4. 处理简单三元表达式的第一部分
  // 匹配如 {{ item.status ? '正常' : ... }}
  const simpleTernaryFirstPartRegex = /(\{\{\s*[\w\.]+\s*\?\s*)(['"])([^'"]*[\u4e00-\u9fa5][^'"]*)(\2)(\s*:)/g;
  
  processedContent = processedContent.replace(simpleTernaryFirstPartRegex, (match, prefix, quote, chineseText, quoteEnd, suffix) => {
    if (debugMode) console.log(`替换简单三元表达式第一部分的中文: ${match} => ${prefix}$t('${chineseText}')${suffix}`);
    countReplacement('interpolation');
    return `${prefix}$t('${chineseText}')${suffix}`;
  });
  
  // 5. 处理简单三元表达式的第二部分
  // 匹配如 {{ item.status ? ... : '异常' }}
  const simpleTernarySecondPartRegex = /(\{\{\s*[\w\.]+\s*\?\s*(?:[^:]+)\s*:\s*)(['"])([^'"]*[\u4e00-\u9fa5][^'"]*)(\2)(\s*\}\})/g;
  
  processedContent = processedContent.replace(simpleTernarySecondPartRegex, (match, prefix, quote, chineseText, quoteEnd, suffix) => {
    if (debugMode) console.log(`替换简单三元表达式第二部分的中文: ${match} => ${prefix}$t('${chineseText}')${suffix}`);
    countReplacement('interpolation');
    return `${prefix}$t('${chineseText}')${suffix}`;
  });
  
  // 6. 处理简单条件表达式
  // 匹配如 {{ item.name || '未命名' }}
  const simpleConditionalRegex = /(\{\{\s*[\w\.]+\s*\|\|\s*)(['"])([^'"]*[\u4e00-\u9fa5][^'"]*)(\2)(\s*\}\})/g;
  
  processedContent = processedContent.replace(simpleConditionalRegex, (match, prefix, quote, chineseText, quoteEnd, suffix) => {
    if (debugMode) console.log(`替换简单条件表达式中的中文: ${match} => ${prefix}$t('${chineseText}')${suffix}`);
    countReplacement('interpolation');
    return `${prefix}$t('${chineseText}')${suffix}`;
  });
  
  return processedContent;
}

// 全局替换所有条件表达式中的中文文本
function replaceAllConditionalExpressions(content) {
  // 处理三元表达式中的嵌套花括号问题
  content = replaceTernaryExpressions(content);
  
  // 处理三元表达式中的中文文本
  content = replaceChineseInTernary(content);
  
  // 匹配 {{ variable || '中文' }} 格式的模式 - 更精确的正则表达式
  const regex = /(\{\{\s*[\w\.]+\s*\|\|\s*)(['"])([^'"{}]+)([\u4e00-\u9fa5]+[^'"{}]*)(\2)(\s*\}\})/g;
  
  // 处理普通的中文条件表达式
  let processedContent = content.replace(regex, (match, prefix, quote, textBefore, textWithChinese, quoteEnd, suffix) => {
    // 如果文本中包含中文
    const fullText = textBefore + textWithChinese;
    if (/[\u4e00-\u9fa5]/.test(fullText)) {
      if (debugMode) console.log(`全局替换条件表达式: ${match} => ${prefix}$t('${fullText}')${suffix}`);
      countReplacement('interpolation');
      return `${prefix}$t('${fullText}')${suffix}`;
    }
    return match; // 不包含中文，保持不变
  });
  
  // 再次匹配，更简单的正则表达式，处理可能被漏掉的情况
  const simpleRegex = /(\{\{\s*[\w\.]+\s*\|\|\s*)(['"])([^'"{}]*)(\2)(\s*\}\})/g;
  processedContent = processedContent.replace(simpleRegex, (match, prefix, quote, text, quoteEnd, suffix) => {
    // 如果文本中包含中文
    if (/[\u4e00-\u9fa5]/.test(text)) {
      if (debugMode) console.log(`全局替换简单条件表达式: ${match} => ${prefix}$t('${text}')${suffix}`);
      countReplacement('interpolation');
      return `${prefix}$t('${text}')${suffix}`;
    }
    return match; // 不包含中文，保持不变
  });
  
  // 处理错误嵌套的情况：{{ variable || '{{$t('暂无')}}' }}
  const nestedRegex = /(\{\{\s*[\w\.]+\s*\|\|\s*)(['"])(\{\{\$t\(['"])([^'"]+)([']\)\}\})(\2)(\s*\}\})/g;
  processedContent = processedContent.replace(nestedRegex, (match, prefix, quote, nestedStart, text, nestedEnd, quoteEnd, suffix) => {
    if (debugMode) console.log(`修复嵌套$t调用条件表达式: ${match} => ${prefix}$t('${text}')${suffix}`);
    countReplacement('interpolation');
    return `${prefix}$t('${text}')${suffix}`;
  });
  
  return processedContent;
}

// 替换脚本中的中文字符串
function replaceScriptContent(content, text, key) {
  const scriptRegex = new RegExp(`(^|[\\s\\.\\(\\[\\{\\,\\:\\=\\+\\-\\*\\/])(['"])(${escapeRegExp(text)})(\\2)(?!\\s*\\)|\\s*\\}\\s*\\)|\\$t|\\w+\\s*:)`, 'gm');
  
  return content.replace(scriptRegex, (match, prefix, quote, chineseText) => {
    // 避免替换已经是i18n调用的内容
    if (match.includes('$t(') || prefix.includes('$t(')) {
      return match;
    }
    if (debugMode) console.log(`替换脚本中的字符串: ${match} => ${prefix}this.$t('${key}')`);
    countReplacement('scriptContent');
    return `${prefix}this.$t('${key}')`;
  });
}

// 修复嵌套$t调用
function fixNestedCalls(content, isScript = false) {
  if (!CONFIG.fixNestedCalls) {
    return content;
  }
  
  if (!isScript) {
    // 模板中的嵌套调用
    return content.replace(/\$t\(\s*\$t\(\s*(['"])([^'"]+)(\1)\s*\)\s*\)/g, (match, quote, key) => {
      if (debugMode) console.log(`修复嵌套$t调用: ${match} => $t('${key}')`);
      return `$t(${quote}${key}${quote})`;
    });
  } else {
    // 脚本中的嵌套调用
    return content.replace(/this\.\$t\(\s*this\.\$t\(\s*(['"])([^'"]+)(\1)\s*\)\s*\)/g, (match, quote, key) => {
      if (debugMode) console.log(`修复脚本中嵌套$t调用: ${match} => this.$t('${key}')`);
      return `this.$t(${quote}${key}${quote})`;
    });
  }
}

// 清理嵌套花括号表达式，例如 "{{$t('请选择')}}" 变为 $t('请选择')
function cleanNestedBracketExpressions(content) {
  // 匹配带引号的嵌套$t表达式模式："{{$t('请选择')}}"
  const nestedBracketRegex = /(['"])\{\{\$t\(['"]([^'"]+)['"]\)\}\}(\1)/g;
  
  let processedContent = content.replace(nestedBracketRegex, (match, openQuote, translationKey, closeQuote) => {
    if (debugMode) console.log(`清理嵌套花括号表达式: ${match} => $t('${translationKey}')`);
    countReplacement('interpolation');
    return `$t('${translationKey}')`;
  });
  
  // 匹配脚本中的嵌套$t表达式，如 this.$t('{{$t('车辆位置成功')}}')
  const scriptNestedRegex = /this\.\$t\(['"](\{\{\$t\(['"])([^'"]+)(['"]\)\}\})["']\)/g;
  processedContent = processedContent.replace(scriptNestedRegex, (match, prefix, translationKey, suffix) => {
    if (debugMode) console.log(`清理脚本中嵌套$t调用: ${match} => this.$t('${translationKey}')`);
    countReplacement('scriptContent');
    return `this.$t('${translationKey}')`;
  });
  
  // 匹配对象属性调用中的嵌套$t表达式
  const objPropNestedRegex = /(get\([^,]+,[^,]+,\s*)(['"])(\{\{\$t\(['"])([^'"]+)(['"]\)\}\})(["]\s*\))/g;
  processedContent = processedContent.replace(objPropNestedRegex, (match, prefix, openQuote, nestedStart, translationKey, nestedEnd, suffix) => {
    if (debugMode) console.log(`清理对象属性嵌套$t调用: ${match} => ${prefix}$t('${translationKey}')${suffix}`);
    countReplacement('scriptContent');
    return `${prefix}$t('${translationKey}')${suffix}`;
  });
  
  // 匹配console.log中的嵌套$t表达式
  const consoleNestedRegex = /(console\.log\(['"])(\{\{\$t\(['"])([^'"]+)(['"]\)\}\})(['"]\))/g;
  processedContent = processedContent.replace(consoleNestedRegex, (match, prefix, nestedStart, translationKey, nestedEnd, suffix) => {
    if (debugMode) console.log(`清理console.log中嵌套$t调用: ${match} => ${prefix}this.$t('${translationKey}')${suffix}`);
    countReplacement('scriptContent');
    return `${prefix}this.$t('${translationKey}')${suffix}`;
  });
  
  // 修复JS中没有带引号的嵌套$t表达式 - console.log('{{$t("用户点击取消")}}')
  processedContent = processedContent.replace(/(console\.log\()(['"])(\{\{\$t\(['"])([^'"]+)(['"]\)\}\})(['"])\)/g, 
    (match, prefix, openQuote, nestedStart, translationKey, nestedEnd, closeQuote) => {
    if (debugMode) console.log(`修复console.log中嵌套$t调用: ${match} => ${prefix}this.$t('${translationKey}')`);
    countReplacement('scriptContent');
    return `${prefix}this.$t('${translationKey}')`; 
  });
  
  // 修复更一般的console.log中的嵌套形式
  processedContent = processedContent.replace(/console\.log\((['"])?\{\{\$t\(['"]([^'"]+)['"]\)\}\}(['"])?\)/g, 
    (match, openQuote, translationKey, closeQuote) => {
    if (debugMode) console.log(`修复一般console.log中嵌套$t调用: ${match} => console.log(this.$t('${translationKey}'))`);
    countReplacement('scriptContent');
    return `console.log(this.$t('${translationKey}'))`; 
  });
  
  // 修复this.$t中没有带引号的嵌套$t表达式 - this.$t('{{$t("车辆位置成功")}}')
  processedContent = processedContent.replace(/(this\.\$t\()(['"])(\{\{\$t\(['"])([^'"]+)(['"]\)\}\})(['"])\)/g, 
    (match, prefix, openQuote, nestedStart, translationKey, nestedEnd, closeQuote) => {
    if (debugMode) console.log(`修复this.$t中嵌套$t调用: ${match} => ${prefix}'${translationKey}')`);
    countReplacement('scriptContent');
    return `${prefix}'${translationKey}')`; 
  });
  
  // 修复更一般的this.$t形式
  processedContent = processedContent.replace(/this\.\$t\((['"])?\{\{\$t\(['"]([^'"]+)['"]\)\}\}(['"])?\)/g, 
    (match, openQuote, translationKey, closeQuote) => {
    if (debugMode) console.log(`修复一般this.$t中嵌套$t调用: ${match} => this.$t('${translationKey}')`);
    countReplacement('scriptContent');
    return `this.$t('${translationKey}')`; 
  });
  
  // 处理JavaScript字符串变量中的嵌套花括号 - const message = '{{$t("操作完成")}}';
  processedContent = processedContent.replace(/((?:const|let|var)\s+\w+\s*=\s*)(['"])(\{\{\$t\(['"])([^'"]+)(['"]\)\}\})(['"])/g,
    (match, prefix, openQuote, nestedStart, translationKey, nestedEnd, closeQuote) => {
    if (debugMode) console.log(`修复JS变量中嵌套$t调用: ${match} => ${prefix}this.$t('${translationKey}')`);
    countReplacement('scriptContent');
    return `${prefix}this.$t('${translationKey}')`; 
  });
  
  // 处理作为参数传递的嵌套花括号 - this.showMessage('{{$t("请确认")}}');
  processedContent = processedContent.replace(/(\.\w+\()(['"])(\{\{\$t\(['"])([^'"]+)(['"]\)\}\})(['"])/g,
    (match, prefix, openQuote, nestedStart, translationKey, nestedEnd, closeQuote) => {
    if (debugMode) console.log(`修复函数参数中嵌套$t调用: ${match} => ${prefix}this.$t('${translationKey}')`);
    countReplacement('scriptContent');
    return `${prefix}this.$t('${translationKey}')`; 
  });
  
  // 匹配对象属性默认值中的嵌套$t表达式，如 ".mergename", "{{$t('无')}}"
  const defaultValueRegex = /(["'],\s*["'])(\{\{\$t\(['"])([^'"]+)(['"]\)\}\})(['"]\s*[,)])/g;
  processedContent = processedContent.replace(defaultValueRegex, (match, prefix, nestedStart, translationKey, nestedEnd, suffix) => {
    if (debugMode) console.log(`清理默认值中的嵌套$t调用: ${match} => ${prefix}$t('${translationKey}')${suffix}`);
    countReplacement('scriptContent');
    return `${prefix}$t('${translationKey}')${suffix}`;
  });
  
  // 匹配三元表达式和条件表达式中的嵌套花括号
  processedContent = processedContent.replace(/(\|\||:|\?)\s*(['"])(\{\{\$t\(['"])([^'"]+)(['"]\)\}\})(\2)/g, 
    (match, operator, quote, nestedStart, translationKey, nestedEnd, endQuote) => {
    if (debugMode) console.log(`清理表达式中的嵌套$t调用: ${match} => ${operator} $t('${translationKey}')`);
    countReplacement('interpolation');
    return `${operator} $t('${translationKey}')`;
  });
  
  // 模板中的条件表达式，例如：{{ inputs[index].startname || "{{$t('请选择')}}" }}
  processedContent = processedContent.replace(/(\{\{\s*[\w\[\].]+\s*\|\|\s*)(['"])(\{\{\$t\(['"])([^'"]+)(['"]\)\}\})(\2)(\s*\}\})/g,
    (match, prefix, openQuote, nestedStart, translationKey, nestedEnd, closeQuote, suffix) => {
    if (debugMode) console.log(`清理模板条件表达式中的嵌套$t调用: ${match} => ${prefix}$t('${translationKey}')${suffix}`);
    countReplacement('interpolation');
    return `${prefix}$t('${translationKey}')${suffix}`;
  });
  
  // 模板中使用get函数的表达式，例如：{{ get(..., "{{$t('无')}}" ) }}
  processedContent = processedContent.replace(/(get\([^,]+,[^,]+,\s*)(['"])(\{\{\$t\(['"])([^'"]+)(['"]\)\}\})(\2)(\s*\))/g,
    (match, prefix, openQuote, nestedStart, translationKey, nestedEnd, closeQuote, suffix) => {
    if (debugMode) console.log(`清理get函数中的嵌套$t调用: ${match} => ${prefix}$t('${translationKey}')${suffix}`);
    countReplacement('interpolation');
    return `${prefix}$t('${translationKey}')${suffix}`;
  });
  
  return processedContent;
}

// 处理文件内容的替换逻辑（针对单个中文文本）
function processFileContent(content, text, key, isScript = false, filePath = "") {
  // 如果文本为空或没有找到对应的翻译键，则直接返回内容
  if (!text || !key) {
    return content;
  }

  let processedContent = content;
  
  // 根据不同的内容类型选择不同的替换策略
  if (!isScript) {
    // 替换模板中的内容
    // 使用循环确保所有实例都被替换
    let lastContent = '';
    let iterationCount = 0;
    
    // 循环替换直到没有更多替换或达到最大迭代次数
    while (lastContent !== processedContent && iterationCount < 10) {
      lastContent = processedContent;
      processedContent = replaceTagContent(processedContent, text, key);
      processedContent = replaceMixedContent(processedContent, text, key);
      processedContent = replaceAttributes(processedContent, text, key);
      processedContent = replaceInterpolation(processedContent, text, key);
      processedContent = replaceConditionalExpressions(processedContent, text, key);
      iterationCount++;
      
      if (debugMode && iterationCount > 1) {
        console.log(`模板迭代 ${iterationCount}: 继续替换 "${text}"`);
      }
    }
    
    if (debugMode && iterationCount >= 10) {
      console.log(`警告: 达到最大迭代次数(10)，可能仍有 "${text}" 未替换`);
    }
  } else {
    // 替换脚本中的内容
    // 同样使用循环确保所有实例都被替换
    let lastContent = '';
    let iterationCount = 0;
    
    while (lastContent !== processedContent && iterationCount < 10) {
      lastContent = processedContent;
      processedContent = replaceScriptContent(processedContent, text, key);
      iterationCount++;
      
      if (debugMode && iterationCount > 1) {
        console.log(`脚本迭代 ${iterationCount}: 继续替换 "${text}"`);
      }
    }
    
    if (debugMode && iterationCount >= 10) {
      console.log(`警告: 达到最大迭代次数(10)，可能仍有 "${text}" 未替换`);
    }
  }
  
  return processedContent;
}

// 从所有文件中收集中文文本
function collectAllChineseTexts(dir) {
  const allChineseTexts = new Set();
  const chineseRegex = /[\u4e00-\u9fa5]+[^\s<>"']*[\u4e00-\u9fa5]+|[\u4e00-\u9fa5]+/g;
  
  function scanDir(dirPath) {
    try {
      const files = fs.readdirSync(dirPath);
      
      files.forEach(file => {
        const filePath = path.join(dirPath, file);
        try {
          const stat = fs.statSync(filePath);
          
          if (stat.isDirectory()) {
            scanDir(filePath); // 递归处理子目录
          } else if (stat.isFile() && path.extname(filePath) === '.vue') {
            try {
              // 读取文件内容
              const content = fs.readFileSync(filePath, 'utf8');
              
              // 先保存所有注释，避免注释内容被收集
              const comments = [];
              let commentIndex = 0;
              
              const contentWithoutComments = content.replace(SINGLE_LINE_COMMENT, match => {
                comments.push(match);
                return `__COMMENT${commentIndex++}__`;
              }).replace(MULTI_LINE_COMMENT, match => {
                comments.push(match);
                return `__COMMENT${commentIndex++}__`;
              });
              
              // 检测是否包含中文
              if (!contentWithoutComments.match(/[\u4e00-\u9fa5]/)) {
                return;
              }
              
              // 提取所有中文文本
              let match;
              while ((match = chineseRegex.exec(contentWithoutComments)) !== null) {
                const text = match[0].trim();
                if (text && text.length > 0) {
                  allChineseTexts.add(text);
                }
              }
            } catch (err) {
              console.error(`读取文件 ${filePath} 时出错:`, err);
            }
          }
        } catch (err) {
          console.error(`处理 ${filePath} 时出错:`, err);
        }
      });
    } catch (err) {
      console.error(`读取目录 ${dir} 时出错:`, err);
    }
  }
  
  scanDir(dir);
  return allChineseTexts;
}

// 处理单个文件（针对特定中文文本）
function processFile(filePath, chineseText, key) {
  try {
    let content = fs.readFileSync(filePath, 'utf8');
    let isModified = false;
    let repetitionCount = 0;
    
    // 如果文件中不包含目标中文文本，直接返回
    if (!content.includes(chineseText)) {
      return false;
    }
    
    if (debugMode) {
      console.log(`文件 ${filePath} 中包含 ${(content.match(new RegExp(escapeRegExp(chineseText), 'g')) || []).length} 处 "${chineseText}"`);
    }
    
    // 首先清理所有嵌套花括号表达式 - 这一步需要在其他处理之前
    const contentBeforeClean = content;
    content = cleanNestedBracketExpressions(content);
    if (content !== contentBeforeClean) {
      isModified = true;
      if (debugMode) console.log(`清理嵌套花括号表达式: "${filePath}"`);
    }
    
    // 特殊处理：检查是否需要处理条件表达式
    if (path.extname(filePath) === '.vue') {
      // 对于.vue文件，先处理条件表达式
      const contentBefore = content;
      content = replaceAllConditionalExpressions(content);
      if (content !== contentBefore) {
        isModified = true;
        if (debugMode) console.log(`处理条件表达式: "${filePath}"`);
      }
    }
    
    // 计算文本在内容中出现的次数
    const textOccurrences = (content.match(new RegExp(escapeRegExp(chineseText), 'g')) || []).length;
    if (debugMode && textOccurrences > 0) {
      console.log(`文件 ${filePath} 中包含 ${textOccurrences} 处 "${chineseText}"`);
    }
    
    // 分离 <template>、<script> 和 <style>
    const templateRegex = /<template>([\s\S]*?)<\/template>/i;
    const scriptRegex = /<script>([\s\S]*?)<\/script>/i;
    
    // 处理模板部分
    const templateMatch = content.match(templateRegex);
    if (templateMatch && templateMatch[1].includes(chineseText)) {
      const templateContent = templateMatch[1];
      const templateOccurrences = (templateContent.match(new RegExp(escapeRegExp(chineseText), 'g')) || []).length;
      if (debugMode) console.log(`模板中包含 ${templateOccurrences} 处 "${chineseText}"`);
      
      const processedTemplate = processFileContent(templateContent, chineseText, key, false, filePath);
      
      // 检查替换后的模板中是否还有未替换的中文文本
      const remainingOccurrences = (processedTemplate.match(new RegExp(escapeRegExp(chineseText), 'g')) || []).length;
      if (debugMode && remainingOccurrences > 0) {
        console.log(`警告: 模板处理后仍有 ${remainingOccurrences} 处 "${chineseText}" 未替换`);
      }
      
      if (processedTemplate !== templateContent) {
        content = content.replace(templateMatch[0], `<template>${processedTemplate}</template>`);
        isModified = true;
        repetitionCount += (templateOccurrences - remainingOccurrences);
      }
    }
    
    // 处理脚本部分
    const scriptMatch = content.match(scriptRegex);
    if (scriptMatch && scriptMatch[1].includes(chineseText)) {
      const scriptContent = scriptMatch[1];
      const scriptOccurrences = (scriptContent.match(new RegExp(escapeRegExp(chineseText), 'g')) || []).length;
      if (debugMode) console.log(`脚本中包含 ${scriptOccurrences} 处 "${chineseText}"`);
      
      const processedScript = processFileContent(scriptContent, chineseText, key, true, filePath);
      
      // 检查替换后的脚本中是否还有未替换的中文文本
      const remainingOccurrences = (processedScript.match(new RegExp(escapeRegExp(chineseText), 'g')) || []).length;
      if (debugMode && remainingOccurrences > 0) {
        console.log(`警告: 脚本处理后仍有 ${remainingOccurrences} 处 "${chineseText}" 未替换`);
      }
      
      if (processedScript !== scriptContent) {
        content = content.replace(scriptMatch[0], `<script>${processedScript}</script>`);
        isModified = true;
        repetitionCount += (scriptOccurrences - remainingOccurrences);
      }
    }
    
    // 最后再次尝试清理所有嵌套花括号表达式 - 确保处理完成后没有嵌套问题
    const finalContentBeforeClean = content;
    content = cleanNestedBracketExpressions(content);
    if (content !== finalContentBeforeClean) {
      isModified = true;
      if (debugMode) console.log(`最终清理嵌套花括号表达式: "${filePath}"`);
    }
    
    // 进行额外的手动检查，查找漏网之鱼
    // 多次尝试特殊替换，直到没有更多替换
    let specialReplacementsMade = true;
    let specialIterationCount = 0;
    let contentBefore = content;
    
    while (specialReplacementsMade && specialIterationCount < 5) {
      const specialRegex = new RegExp(`(>[^<]*?)(${escapeRegExp(chineseText)})([^>]*?<)`, 'g');
      const specialReplacement = (match, before, text, after) => {
        // 避免替换已经是$t调用的内容
        if (before.includes('$t(') || after.includes('$t(')) {
          return match;
        }
        return `${before}{{$t('${key}')}}${after}`;
      };
      
      contentBefore = content;
      content = content.replace(specialRegex, specialReplacement);
      
      // 检查是否有变化
      specialReplacementsMade = (content !== contentBefore);
      if (specialReplacementsMade) {
        isModified = true;
        if (debugMode) console.log(`特殊替换迭代 ${specialIterationCount + 1}: "${chineseText}" -> "$t('${key}')"`);
      }
      
      specialIterationCount++;
    }
    
    // 尝试另一种特殊替换方法
    const finalSpecialRegex = new RegExp(`(^|[^{])(${escapeRegExp(chineseText)})(?![^<]*>|[^{]*})`, 'g');
    contentBefore = content;
    content = content.replace(finalSpecialRegex, (match, before, text) => {
      // 避免替换已经是$t调用或HTML标签内的内容
      if (before.includes('$t(') || match.includes('{{') || match.includes('}}')) {
        return match;
      }
      return `${before}{{$t('${key}')}}`;
    });
    
    if (content !== contentBefore) {
      isModified = true;
      if (debugMode) console.log(`进行了最终特殊替换: "${chineseText}" -> "$t('${key}')"`);
    }
    
    // 只有当文件被修改时才写入
    if (isModified) {
      fs.writeFileSync(filePath, content, 'utf8');
      if (debugMode) {
        console.log(`已更新文件: ${filePath} (处理文本: "${chineseText}" -> "${key}", 替换了 ${repetitionCount} 处)`);
      }
      return true;
    }
    
    return false;
  } catch (error) {
    console.error(`处理文件 ${filePath} 时出错:`, error);
    return false;
  }
}

// 处理整个目录（针对特定中文文本）
function processDirectoryForText(dir, chineseText, key) {
  let replacementsMade = 0;
  
  function scanAndProcess(dirPath) {
    try {
      const files = fs.readdirSync(dirPath);
      
      files.forEach(file => {
        const filePath = path.join(dirPath, file);
        
        try {
          const stat = fs.statSync(filePath);
          
          if (stat.isDirectory()) {
            replacementsMade += scanAndProcess(filePath); // 递归处理子目录
          } else if (stat.isFile() && path.extname(filePath) === '.vue') {
            // 处理单个文件
            if (processFile(filePath, chineseText, key)) {
              replacementsMade++;
            }
          }
        } catch (err) {
          console.error(`处理 ${filePath} 时出错:`, err);
        }
      });
    } catch (err) {
      console.error(`读取目录 ${dirPath} 时出错:`, err);
    }
    
    return replacementsMade;
  }
  
  return scanAndProcess(dir);
}

// 最后修复所有文件中的嵌套$t调用
function fixNestedCallsInAllFiles(dir) {
  let fixedFiles = 0;
  
  function scanAndFix(dirPath) {
    try {
      const files = fs.readdirSync(dirPath);
      
      files.forEach(file => {
        const filePath = path.join(dirPath, file);
        
        try {
          const stat = fs.statSync(filePath);
          
          if (stat.isDirectory()) {
            fixedFiles += scanAndFix(filePath); // 递归处理子目录
          } else if (stat.isFile() && path.extname(filePath) === '.vue') {
            try {
              // 读取文件内容
              let content = fs.readFileSync(filePath, 'utf8');
              let isModified = false;
              
              // 分离 <template>、<script> 和 <style>
              const templateRegex = /<template>([\s\S]*?)<\/template>/i;
              const scriptRegex = /<script>([\s\S]*?)<\/script>/i;
              
              // 处理模板部分
              const templateMatch = content.match(templateRegex);
              if (templateMatch) {
                const fixedTemplate = fixNestedCalls(templateMatch[1], false);
                if (fixedTemplate !== templateMatch[1]) {
                  content = content.replace(templateRegex, `<template>${fixedTemplate}</template>`);
                  isModified = true;
                }
              }
              
              // 处理脚本部分
              const scriptMatch = content.match(scriptRegex);
              if (scriptMatch) {
                const fixedScript = fixNestedCalls(scriptMatch[1], true);
                if (fixedScript !== scriptMatch[1]) {
                  content = content.replace(scriptRegex, `<script>${fixedScript}</script>`);
                  isModified = true;
                }
              }
              
              // 只有当文件被修改时才写入
              if (isModified) {
                fs.writeFileSync(filePath, content, 'utf8');
                if (debugMode) {
                  console.log(`已修复嵌套调用: ${filePath}`);
                }
                return 1;
              }
            } catch (err) {
              console.error(`修复嵌套调用时出错 ${filePath}:`, err);
            }
          }
        } catch (err) {
          console.error(`处理 ${filePath} 时出错:`, err);
        }
      });
    } catch (err) {
      console.error(`读取目录 ${dirPath} 时出错:`, err);
    }
    
    return fixedFiles;
  }
  
  return scanAndFix(dir);
}

// 主程序
const startTime = Date.now();
console.log('开始处理Vue文件的国际化...');

// 检查源目录是否存在
const pagesDir = path.resolve(process.cwd(), sourceDir);
if (!fs.existsSync(pagesDir)) {
  console.error(`错误: 目录 ${pagesDir} 不存在!`);
  process.exit(1);
}

// 测试处理单个文件的嵌套花括号
function processSingleFile(filePath) {
  if (!fs.existsSync(filePath)) {
    console.error(`错误: 文件 ${filePath} 不存在!`);
    return false;
  }
  
  try {
    console.log(`处理单个文件: ${filePath}`);
    // 读取文件内容
    let content = fs.readFileSync(filePath, 'utf8');
    console.log('原始内容:');
    console.log(content);
    
    // 应用清理嵌套花括号表达式
    const cleanedContent = cleanNestedBracketExpressions(content);
    
    // 只有当文件被修改时才写入
    if (cleanedContent !== content) {
      fs.writeFileSync(filePath, cleanedContent, 'utf8');
      console.log('清理后内容:');
      console.log(cleanedContent);
      return true;
    } else {
      console.log('文件未发生变化');
      return false;
    }
  } catch (err) {
    console.error(`处理文件 ${filePath} 时出错:`, err);
    return false;
  }
}

// 检查是否指定了单个文件处理
const singleFilePath = path.join(pagesDir, 'test_newer.vue');
if (fs.existsSync(singleFilePath)) {
  console.log('检测到测试文件，进行单独处理...');
  const processed = processSingleFile(singleFilePath);
  if (processed) {
    console.log('测试文件处理完成');
  }
}

// 预处理步骤：清理所有嵌套花括号表达式
console.log('预处理：清理所有嵌套花括号表达式...');
function preprocessFiles(dir) {
  let processedFiles = 0;
  
  function scanAndPreprocess(dirPath) {
    try {
      const files = fs.readdirSync(dirPath);
      
      files.forEach(file => {
        const filePath = path.join(dirPath, file);
        
        try {
          const stat = fs.statSync(filePath);
          
          if (stat.isDirectory()) {
            scanAndPreprocess(filePath); // 递归处理子目录
          } else if (stat.isFile() && path.extname(filePath) === '.vue') {
            try {
              // 读取文件内容
              let content = fs.readFileSync(filePath, 'utf8');
              
              // 先应用清理嵌套花括号表达式
              const cleanedContent = cleanNestedBracketExpressions(content);
              
              // 只有当文件被修改时才写入
              if (cleanedContent !== content) {
                fs.writeFileSync(filePath, cleanedContent, 'utf8');
                processedFiles++;
                if (debugMode) {
                  console.log(`预处理：清理嵌套花括号表达式: ${filePath}`);
                }
              }
            } catch (err) {
              console.error(`预处理文件 ${filePath} 时出错:`, err);
            }
          }
        } catch (err) {
          console.error(`处理 ${filePath} 时出错:`, err);
        }
      });
    } catch (err) {
      console.error(`读取目录 ${dirPath} 时出错:`, err);
    }
    
    return processedFiles;
  }
  
  return scanAndPreprocess(dir);
}

const preprocessedFiles = preprocessFiles(pagesDir);
if (debugMode) {
  console.log(`预处理完成: 处理了 ${preprocessedFiles} 个文件的嵌套花括号表达式`);
}

// 第一步：收集所有中文文本
console.log('正在扫描所有文件，收集中文文本...');
const allChineseTexts = collectAllChineseTexts(pagesDir);
console.log(`共收集到 ${allChineseTexts.size} 个中文文本片段`);

// 创建已处理和未处理的中文文本集合
const processedChineseTexts = new Set();
const untranslatedTexts = new Set();

// 第二步：逐个处理中文文本
console.log('开始逐个处理中文文本...');
let totalProcessedFiles = 0;

// 将中文文本转换为数组并排序（按长度降序排列，优先处理较长的文本以避免部分替换）
const sortedTexts = Array.from(allChineseTexts).sort((a, b) => b.length - a.length);

for (const text of sortedTexts) {
  // 检查是否有对应的翻译键
  const key = translationsMap[text];
  
  if (key) {
    console.log(`处理中文文本: "${text}" -> "${key}"`);
    
    // 处理整个目录中的该文本
    const fileCount = processDirectoryForText(pagesDir, text, key);
    totalProcessedFiles += fileCount;
    
    // 标记为已处理
    processedChineseTexts.add(text);
  } else {
    // 没有找到翻译的文本
    untranslatedTexts.add(text);
    if (debugMode) {
      console.log(`未找到翻译: "${text}"`);
    }
  }
}

// 第三步：修复所有文件中的嵌套$t调用
console.log('修复嵌套的$t调用...');
const fixedFilesCount = fixNestedCallsInAllFiles(pagesDir);

// 最后再次处理嵌套花括号表达式，确保所有嵌套形式都被处理
console.log('最终处理：再次清理所有嵌套花括号表达式...');
const finalProcessedFiles = preprocessFiles(pagesDir);
if (debugMode) {
  console.log(`最终处理完成: 处理了 ${finalProcessedFiles} 个文件的嵌套花括号表达式`);
}

const endTime = Date.now();

// 输出统计结果
console.log('\n------ 处理结果统计 ------');
console.log(`总完成替换: ${globalReplacementCount} 处`);
console.log(`处理文件数: ${totalProcessedFiles} 个`);
console.log(`修复嵌套调用的文件数: ${fixedFilesCount} 个`);
console.log(`清理嵌套花括号表达式的文件数: ${preprocessedFiles + finalProcessedFiles} 个`);
console.log(`已处理的中文文本: ${processedChineseTexts.size} 个`);
console.log(`未翻译的中文文本: ${untranslatedTexts.size} 个`);
console.log(`总耗时: ${((endTime - startTime) / 1000).toFixed(2)} 秒`);

// 输出替换类型统计
if (outputStats) {
  console.log('\n------ 替换类型统计 ------');
  console.log(`标签内文本: ${replacementStats.tagContent} 处`);
  console.log(`混合内容: ${replacementStats.mixedContent} 处`);
  console.log(`属性: ${replacementStats.attributes} 处`);
  console.log(`插值表达式: ${replacementStats.interpolation} 处`);
  console.log(`脚本内容: ${replacementStats.scriptContent} 处`);
}

// 如果存在未能翻译的中文文本，可选择输出到文件
if (exportUntranslated && untranslatedTexts.size > 0) {
  console.log(`\n发现 ${untranslatedTexts.size} 个未翻译的中文文本`);
  try {
    const outputPath = path.join(process.cwd(), 'untranslated.json');
    fs.writeFileSync(outputPath, JSON.stringify(Array.from(untranslatedTexts), null, 2), 'utf8');
    console.log(`已将未翻译文本保存至: ${outputPath}`);
  } catch (error) {
    console.error('保存未翻译文本时出错:', error);
  }
}